#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <iomanip>
#include <string>
#include <math.h>
using namespace std;

//求一元二次方程的实根
class root
{
public:
	root(float x,float y,float z):a(x),b(y),c(z){}//构造函数
	void answer();
private:
	double a;
	double b;
	double c;
};

void root::answer()
{
	try
	{
		double judge = b * b - 4 * a * c;
		if (judge < 0)
		{
			//方程无实根
			throw a;
		}
		else if (judge == 0)
		{
			//方程有两个相等的实根
			double ans = (-b + sqrt(judge)) / (2 * a);
			cout << "x1 = " << ans << ",x2 = " << ans << endl;
		}
		else
		{
			//方程有两个不同的实根
			double ans1 = (-b + sqrt(judge)) / (2 * a);
			double ans2 = (-b - sqrt(judge)) / (2 * a);
			cout << "x1 = " << ans1 << ",x2 = " << ans2 << endl;

		}
	}
	catch(double)
	{
		cout << "该方程没有实根" << endl;
	}
}

int main()
{
	root r(1, 4, 3);
	r.answer();
	root s(1, 1, 1);
	s.answer();
	return 0;
}

////抽象基类
//class shape
//{
//public:
//	virtual void shapename()const = 0;
//	virtual float printarea()const { return 0.0; }
//};
//
////圆形类
//class Circle :public shape
//{
//public:
//	Circle(float r):radius(r){}
//	virtual void shapename()const { cout << "Circle:" << endl; }
//	virtual float printarea()const;
//	friend ostream& operator<<(ostream& output, Circle& circle);
//protected:
//	float radius;
//};
//
//float Circle::printarea()const
//{
//	return float(3.14159 * pow(radius, 2));
//}
//
//ostream& operator<<(ostream& output, Circle& circle)
//{
//	output << "radius = " << circle.radius << endl;
//	return output;
//}
//
////矩形类
//class Rectangle :public shape
//{
//public:
//	Rectangle(float x, float y):length(x),wideth(y){}
//	virtual void shapename()const { cout << "Rectangle:" << endl; }
//	virtual float printarea()const;
//	friend ostream& operator<<(ostream& output, Rectangle& rectangle);
//protected:
//	float length;
//	float wideth;
//};
//
//float Rectangle::printarea() const
//{
//	return length * wideth;
//}
//
//ostream& operator<<(ostream& output, Rectangle& rectangle)
//{
//	output << "length = " << rectangle.length << " " << "wideth = " << rectangle.wideth << endl;
//	return output;
//}
//
////三角形类
//class Triangle :public shape
//{
//public:
//	Triangle(float x,float y,float z):a(x),b(y),c(z){}
//	virtual void shapename()const { cout << "Triangle:" << endl; }
//	virtual float printarea()const;
//	friend ostream& operator<<(ostream& output, Triangle& triangle);
//protected:
//	float a;
//	float b;
//	float c;
//};
//
//float Triangle::printarea()const
//{
//	float s = (a + b + c) / 2;
//	float middle = s * (s - a) * (s - b) * (s - c);
//	float area = float(sqrt(middle));
//	return area;
//}
//
//ostream& operator<<(ostream& output, Triangle& triangle)
//{
//	output << "a = " << triangle.a << "," << "b = " << triangle.b << "," << "c = " << triangle.c << endl;
//	return output;
//}
//
//int main()
//{
//	Circle circle(1);
//	//circle.shapename();
//	//cout<<circle.printarea()<<endl;
//	//cout << circle;
//
//	Rectangle rectangle(2, 3);
//	//rectangle.shapename();
//	//cout << rectangle.printarea() << endl;
//	//cout << rectangle;
//
//	Triangle triangle(3, 4, 5);
//	//triangle.shapename();
//	//cout << triangle.printarea() << endl;
//	//cout << triangle;
//
//	shape* ptr = &circle;
//	ptr->shapename();
//	cout << ptr->printarea() << endl;
//
//	ptr = &rectangle;
//	ptr->shapename();
//	cout << ptr->printarea() << endl;
//
//	ptr = &triangle;
//	ptr->shapename();
//	cout << ptr->printarea() << endl;
//
//	return 0;
//}

//class Matrix
//{
//public:
//	Matrix(){}
//	friend Matrix operator+(Matrix& a, Matrix& b);
//	friend ostream& operator<<(ostream& output,Matrix& c);
//	friend istream& operator>>(istream& input, Matrix& c);
//private:
//	int arr[2][3];
//};
//
//Matrix operator+(Matrix& a, Matrix& b)
//{
//	Matrix c;
//	int i = 0;
//	for (i = 0; i < 2; i++)
//	{
//		int j = 0;
//		for (j = 0; j < 3; j++)
//		{
//			c.arr[i][j] = a.arr[i][j] + b.arr[i][j];
//		}
//	}
//	return c;
//}
//
//istream& operator>>(istream& input, Matrix& c)
//{
//	cout << "please input the number of the Matrix:" << endl;
//	int i = 0;
//	for (i = 0; i < 2; i++)
//	{
//		if (0 == i)
//		{
//			cout << "the first line:";
//		}
//		else
//		{
//			cout << "the second line:";
//		}
//		int j = 0;
//		for (j = 0; j < 3; j++)
//		{
//			input >> c.arr[i][j];
//		}
//	}
//	return input;
//}
//
//ostream& operator<<(ostream& output, Matrix& c)
//{
//	int i = 0;
//	for (i = 0; i < 2; i++)
//	{
//		int j = 0;
//		for (j = 0; j < 3; j++)
//		{
//			output << c.arr[i][j]<<" ";
//		}
//		output << endl;
//	}
//	return output;
//}
//
//int main()
//{
//	Matrix a;
//	cin >> a;
//	cout << a;
//
//	Matrix b;
//	cin >> b;
//	cout << b;
//
//	Matrix c;
//	c = a + b;
//	cout << c;
//
//	return 0;
//}

//class Complex
//{
//public:
//	Complex(double a, double b) :real(a), imag(b) {}
//	friend Complex operator+(Complex a, Complex b);
//	friend Complex operator+(int a, Complex b);
//	friend Complex operator+(Complex a, int b);
//	friend ostream& operator<<(ostream& output, Complex c);
//private:
//	double real;
//	double imag;
//};
//
//Complex operator+(int a, Complex b)
//{
//	Complex c(0, 0);
//	c.real = a + b.real;
//	c.imag = b.imag;
//	return c;
//}
//
//Complex operator+(Complex a, int b)
//{
//	Complex c(0, 0);
//	c.real = a.real + b;
//	c.imag = a.imag ;
//	return c;
//}
//
//Complex operator+(Complex a, Complex b)
//{
//	Complex c(0,0);
//	c.real = a.real + b.real;
//	c.imag = a.imag + b.imag;
//	return c;
//}
//
//ostream& operator<<(ostream& output, Complex c)
//{
//	output << c.real << "+" << c.imag << "i" << endl;
//	return output;
//}
//
//int main()
//{
//	Complex a(1, 1);
//	Complex b(1, 1);
//	cout << a;
//	cout << b;
//	Complex c = a + 2;
//	cout << c;
//	c = 1 + c;
//	cout << c;
//	return 0;
//}

//class Complex
//{
//public:
//	Complex(double a, double b) :real(a), imag(b){}
//	Complex operator+ (Complex c);
//	Complex operator- (Complex c);
//	Complex operator* (Complex c);
//	Complex operator/ (Complex c);
//	friend ostream& operator<<(ostream& output, Complex c);
//private:
//	double real;
//	double imag;
//};
//
//Complex Complex::operator+(Complex c)
//{
//	Complex x(0, 0);
//	x.imag = this->imag + c.imag;
//	x.real = this->real + c.real;
//	return x;
//}
//
//Complex Complex::operator- (Complex c)
//{
//	Complex x(0, 0);
//	x.imag = this->imag - c.imag;
//	x.real = this->real - c.real;
//	return x;
//}
//Complex Complex::operator* (Complex c)
//{
//	Complex x(0, 0);
//	x.real = (this->real * c.real) - (this->imag * c.imag);
//	x.imag = (this->imag * c.real) + (this->real * c.imag);
//	return x;
//}
//Complex Complex::operator/ (Complex c)
//{
//	Complex x(0, 0);
//	x.real = ((this->real * c.real) + (this->imag * c.imag)) / ((c.real * c.real) + (c.imag * c.imag));
//	x.imag = ((this->imag * c.real) - (this->real * c.imag)) / ((c.real * c.real) + (c.imag * c.imag));
//	return x;
//}
//
//ostream& operator<<(ostream& output, Complex c)
//{
//	if (0 == c.real && 0 == c.imag)
//	{
//		output << 0 << endl;
//	}
//	else if (0 == c.real)
//	{
//		output << c.imag << "i" << endl;
//	}
//	else
//	{
//		output << c.real << "+" << c.imag << "i" << endl;
//	}
//	return output;
//}
//
//int main()
//{
//	Complex a(1, 1);
//	Complex b(1, 2);
//	//Complex c = a.operator+(b);
//	Complex c = a-b;
//	cout << a << endl;
//	cout << b << endl;
//	cout << c << endl;
//	return 0;
//}

//class Complex
//{
//public:
//	Complex(double a = 0,double b = 0):real(a),imag(b){}
//	friend Complex operator+(Complex a, Complex b);
//	friend ostream& operator<<(ostream& output, Complex c);
//private:
//	double real;
//	double imag;
//};
//
//Complex operator+(Complex a, Complex b)
//{
//	Complex c;
//	c.real = a.real + b.real;
//	c.imag = a.imag + b.imag;
//	return c;
//}
//
//ostream& operator<<(ostream& output, Complex c)
//{
//	output << c.real << "+" << c.imag << "i" << endl;
//	return output;
//}
//
//int main()
//{
//	Complex a(1, 1);
//	Complex b(3, 1);
//	cout << a;
//	cout << b;
//	Complex c = a + b;
//	cout << c;
//	return 0;
//}

////转换构造函数
////将某个数据类型转换成某个类的对象
//class Complex
//{
//public:
//	Complex(double a,double b):real(a),imag(b){}
//	Complex(double a);//转换构造函数
//
//	friend ostream& operator<<(ostream& outpur, Complex& x);
//	operator double() //类型转换函数
//	{ 
//		return real; 
//	}
//private:
//	double real;
//	double imag;
//};
//
//Complex::Complex(double a)//转换构造函数
//{
//	real = a;
//	imag = 0;
//}
//
//ostream& operator<<(ostream& output, Complex& x)
//{
//	cout << x.real << "+" << x.imag << "i" << endl;
//	return output;
//}
//
//int main()
//{
//	Complex x(1, 1);
//	Complex z(2.1);
//	cout << x << endl;
//	cout << z << endl;
//	return 0;
//}

////重载流插入运算符“<<”与流输入运算符“>>”
//class Complex
//{
//public:
//	Complex(double a = 0.0,double b = 0.0):real(a),imag(b){}
//	friend ostream& operator<<(ostream& output, Complex& x);
//	friend istream& operator>>(istream& input, Complex& x);
//private:
//	double real;
//	double imag;
//};
//
//ostream& operator<<(ostream& output, Complex& x)
//{
//	output << x.real << "+" << x.imag << "i" << endl;
//	return output;
//}
//
//istream& operator>>(istream& input, Complex& x)
//{
//	cout << "please input the Complex of real and imag:";
//	input >> x.real >> x.imag;
//	return input;
//}
//
//int main()
//{
//	Complex a;
//	cout << a << endl;
//	cin >> a;
//	cout << a << endl;
//	return 0;
//}

////单目运算符重载
////单目运算符最好重载为成员函数
//class Time
//{
//public:
//	Time(int a = 0,int b = 0):min(a),sec(b){}
//	~Time(){}
//	void display();
//	Time operator++();
//	Time operator--();
//	Time operator++(int);
//	Time operator--(int);
//private:
//	int min;
//	int sec;
//};
//
//void Time::display()
//{
//	cout << min << ":" << sec << endl;
//}
//
//Time Time::operator++()//前置++
//{
//	if ((++sec) >= 60)
//	{
//		sec -= 60;
//		min++;
//	}
//	return *this;
//}
//
//Time Time::operator--()//前置--
//{
//	if ((--sec) < 0)
//	{
//		sec = 59;
//		min--;
//	}
//	return *this;
//}
//
//Time Time::operator++(int)//后置++
//{
//	Time tmp(*this);
//	sec++;
//	if (sec >= 60)
//	{
//		sec -= 60;
//		min++;
//	}
//	return tmp;
//}
//
//Time Time::operator--(int)//后置--
//{
//	Time tmp(*this);
//	sec--;
//	if (sec < 0)
//	{
//		sec = 59;
//		min--;
//	}
//	return tmp;
//}
//
//int main()
//{
//	//int a1 = 3;
//	//int b = a1++;
//	//cout << a1 << " " << b<<endl;
//
//	//Time a(12, 12);
//	//Time c = a++;//后置++，将未改变前的对象给新对象，然后旧对象自加
//	//c.display();
//	//a.display();
//
//	//Time b(3, 1);
//	//Time d = ++b;//前置++，将对象改变后的值复制给新对象
//	//d.display();
//	//b.display();
//	//Time a(1, 1);
//	//a.display();
//	//++a;
//	//a.display();
//	//Time b(3,1);
//	//b.display();
//	//b++;
//	//b.display();
//	//b--;
//	//b.display();
//	//b--;
//	//b.display();
//	//b--;
//	//b.display();
//	return 0;
//}

////双目运算符重载
// 双目运算符最好重载为友元函数
//class Complex
//{
//public:
//	Complex(double a = 0, double b = 0) :real(a), imag(b) {}
//	~Complex() { ; }
//	friend Complex operator+(Complex a, Complex b);
//	void display();
//private:
//	double real;
//	double imag;
//};
//
//Complex operator+(Complex a, Complex b)
//{
//	Complex c;
//	c.real = a.real + b.real;
//	c.imag = a.imag + b.imag;
//	return c;
//}
//
//void Complex::display()
//{
//	cout << real << "+" << imag << "i" << endl;
//}
//
//int main()
//{
//	Complex a;
//	Complex b(1,3);
//	Complex c = a + b;
//	a.display();
//	b.display();
//	c.display();
//	return 0;
//}


////运算符重载
//class Complex
//{
//public:
//	Complex(int i = 0,int j = 0):real(i),imag(j){}
//	~Complex() { ; }
//	Complex operator+(Complex& x1);
//	Complex operator-(Complex& x1);
//	//Complex operator*(Complex& x1);
//	//Complex operator/(Complex& x1);
//	void display();
//private:
//	int real;
//	int imag;
//};
//
//Complex Complex:: operator+(Complex& x1)
//{
//	Complex c;
//	c.real = real + x1.real;
//	c.imag = imag + x1.imag;
//	return c;
//}
//
//Complex Complex::operator-(Complex& x1)
//{
//	Complex c;
//	c.real = real - x1.real;
//	c.imag = imag - x1.imag;
//	return c;
//}
//
//void Complex::display()
//{
//	if (imag == 0 && real == 0)
//	{
//		cout << 0 << endl;
//	}
//	else if (imag == 0)
//	{
//		cout << real << endl;
//	}
//	else if (real == 0)
//	{
//		cout << imag << "i" << endl;
//	}
//	else
//	{
//		cout << real << "+" << imag << "i" << endl;
//	}
//}
//
//int main()
//{
//	Complex a(1, 1);
//	Complex b(1, 2);
//	Complex c;
//	c = a - b;
//	c.display();
//	return 0;
//}

//template<class type>
//class Compare
//{
//public:
//	Compare(type x, type y):x(x),y(y){}
//	type max();
//	type min();
//private:
//	type x;
//	type y;
//};
//
//template<class type>
//type Compare<type>::max()
//{
//	return x > y ? x : y;
//}
//
//template<class type>
//type Compare<type>::min()
//{
//	return x < y ? x : y;
//}
//
//int main()
//{
//	Compare<int> c(1, 3);
//	cout << c.max() << endl;
//	cout << c.min() << endl;
//	return 0;
//}

//class Time;
//class Date;
//
//class Time
//{
//public:
//	Time(int h, int m, int s) :hour(h), minute(m), second(s) {}
//	void display(Date& d);
//private:
//	int hour;
//	int minute;
//	int second;
//};
//
//class Date
//{
//public:
//	Date(int m, int d, int y) :month(m), day(d), year(y) {}
//	friend Time;
//private:
//	int month;
//	int day;
//	int year;
//};
//
//void Time::display(Date & d)
//{
//	cout << hour << ":" << minute << ":" << second << endl;
//	cout << d.month << "/" << d.day << "/" << d.year << endl;
//}
//
//int main()
//{
//	Time t(1, 1, 1);
//	Date d(5, 22, 2024);
//	t.display(d);
//	return 0;
//}


//class Time;
//class Date;
//
//class Time
//{
//public:
//	Time(int h,int m,int s):hour(h),minute(m),second(s){}
//	friend void display(Time& t, Date& d);
//private:
//	int hour;
//	int minute;
//	int second;
//};
//
//class Date
//{
//public:
//	Date(int m,int d,int y):month(m),day(d),year(y){}
//	friend void display(Time& t, Date& d);
//private:
//	int month;
//	int day;
//	int year;
//};
//
//void display(Time& t, Date& d)
//{
//	cout << t.hour << ":" << t.minute << ":" << t.second << endl;
//	cout << d.month << "/" << d.day << "/" << d.year << endl;
//}
//
//int main()
//{
//	Time t(1, 1, 1);
//	Date d(5, 22, 2024);
//	display(t,d);
//	return 0;
//}

//class sale
//{
//public:
//	sale(int num,int quantity,float price):num(num),quantity(quantity),price(price){}
//	~sale() { ; }
//	void Sum()
//	{
//		sum += quantity*price;
//		count += quantity;
//	}
//	static float Average()
//	{
//		return (float)sum / count;
//	}
//	static void show()
//	{
//		cout << sum << endl << Average() << endl;
//	}
//private:
//	int num;
//	int quantity;
//	float price;
//	static float sum;
//	static int count;
//	static float average;
//};
//
//int sale::count = 0;
//float sale::sum = 0;
//float sale::average = 0.0;
//
//int main()
//{
//	sale s[3] = {
//		sale(101,5,23.5f),
//		sale(102,12,24.56f),
//		sale(103,100,21.5f)
//	};
//	int i = 0;
//	for (i = 0; i < 3; i++)
//	{
//		s[i].Sum();
//	}
//	sale::show();
//	return 0;
//}

//class student
//{
//public:
//	student(int num, int score) :num(num), score(score) {}
//	~student()
//	{
//		cout << "deleted" << endl;
//	}
//	void display()
//	{
//		cout << num << "->" << score << endl;
//	}
//	student max(student* p);
//private:
//	int num;
//	int score;
//};
//
//student student::max(student* p)
//{
//	student max = *p;
//	int i = 0;
//	for (i = 1; i < 5; i++)
//	{
//		p++;
//		if (p->score > max.score)
//		{
//			max = *p;
//		}
//		
//	}
//	return max;
//}
//
//int main()
//{
//	//创建对象数组
//	student stu[5] = {
//		student(1,10),
//		student(2,20),
//		student(3,96),
//		student(4,40),
//		student(5,50)
//	};
//	student t = t.max(stu);
//	t.display();
//	return 0;
//}

//class student
//{
//public:
//	student(int num,int score):num(num),score(score){}
//	~student()
//	{
//		cout << "deleted" << endl;
//	}
//	void display()
//	{
//		cout << num << "->" << score << endl;
//	}
//private:
//	int num;
//	int score;
//};
//
//int main()
//{
//	//创建对象数组
//	student stu[5] = {
//		student(1,10),
//		student(2,20),
//		student(3,30),
//		student(4,40),
//		student(5,50)
//	};
//	student* p = stu;
//	p->display();
//	p +=2 ;
//	p->display();
//	p += 2;
//	p->display();
//	return 0;
//}

//class Data
//{
//public:
//	Data(int = 1, int = 1, int = 2005);
//	~Data() { ; }
//	void display();
//private:
//	int month;
//	int day;
//	int year;
//};
//
//Data::Data(int m,int d,int y):month(m),day(d),year(y){}
//void Data::display()
//{
//	cout << month << "/" << day << "/" << year << endl;
//}
//
//int main()
//{
//	Data d1(10, 13, 2005);
//	Data d2(12, 30);
//	Data d3(10);
//	Data d4;
//	d1.display();
//	d2.display();
//	d3.display();
//	d4.display();
//	return 0;
//}

////类模板
//template<class digitname>
//class compare
//{
//public:
//	compare(digitname a,digitname b):a(a),b(b){}
//	~compare(){ ; }
//	digitname max()
//	{
//		return a > b ? a : b;
//	}
//	digitname min();
//private:
//	digitname a;
//	digitname b;
//};
//
////定义在类外的类模板成员函数
//template<class digitname>
//digitname compare<digitname>::min()
//{
//	return a < b ? a : b;
//}
//
//int main()
//{
//	compare<int>t1(1, 2);
//	cout << t1.max() << " " << t1.min() << endl;
//
//	compare<float>t2(3.1, 3);
//	cout << t2.max() << " " << t2.min() << endl;
//	return 0;
//}
//对象的动态建立和释放
//class Time
//{
//public:
//	Time(int h,int m,int s):hour(h),minute(m),second(s){}
//	~Time() { cout << "end" << endl; }
//	void get_time();
//private:
//	int hour;
//	int minute;
//	int second;
//};
//
//void Time::get_time()
//{
//	cout << hour << ":" << minute << ":" << second << endl;
//}
//
//int main()
//{
//	Time* p = new Time(1, 1, 1);
//	if (p == NULL)
//	{
//		perror("new");
//		exit(-1);
//	}
//	p->get_time();
//	p = NULL;
//	delete p;
//	return 0;
//}

//对象的常引用
//class Time
//{
//public:
//	int hour;
//	int minute;
//	int second;
//	Time(int h,int m,int s):hour(h),minute(m),second(s){}
//	~Time(){ ; }
//};
//void func1(Time& t)
//{
//	t.hour = 32;
//}
//void func2(const Time& t)//这里定义形参为常引用，即不可以改变引用的值
//{
//	t.hour = 1;//非法
//}
//int main()
//{
//	Time t(1, 1, 1);
//	cout << t.hour << endl;
//	func1(t);
//	cout << t.hour << endl;
//	return 0;
//}

//对于指向常对象的指针和指向对象的常指针，其实就在于const的位置
//const在*左边，那就是指向常对象的指针，const在*右边，那就是指向对象的常指针
//左定值右定向，const修饰不变量
//如果一个变量已被声明为常变量，只能用指向常变量的指针变量指向它
//指向常变量的指针变量除了可以指向常变量外，还可以指向未被声明为const的变量
//class Time
//{
//public:
//	int hour;
//	int minute;
//	int second;
//	Time(int h, int m, int s) :hour(h), minute(m), second(s) {}
//	~Time() { ; }
//};
//
//int main()
//{
//	//指向对象的常指针
//	Time t1(1, 1, 1);
//	Time* const p = &t1;//这里定义p是一个常指针，即p的指向不可以改变
//	Time t2(2, 2, 2);
//	p = &t2;//这里将p的指向改为t2是非法的
//
//	//但是可以通过常指针改变其指向对象的值
//	p->hour = 13;
//
//	//指向常对象的指针变量
//	Time t3(3, 3, 3);
//	const Time* p2 = &t3;//这里定义p2是一个指向常对象的指针变量，即p2所指向的对象的值不可被修改，但是指向可以改变
//	p2->hour = 1;//错误，不可以修改p2指向对象的值
//	Time t4(4, 4, 4);
//	p2 = &t4;//合法，可以改变该指针的指向
//	return 0;
//}

//const对象，不能被普通成员函数引用，只能被常成员函数引用并且常成员函数不能修改其值
//const数据成员，普通成员函数和常成员函数都可以引用，但是都不可以改变其值
//普通数据成员，普通成员函数和常成员函数都可以引用，前者可以改变其值，后者不可以改变其值
//对于const对象而言，其中的数据成员都是不可被修改的，如果想要修改，可以用mutable定义该数据成员
//常成员函数不能调用另一个普通成员函数
//
//class Time
//{
//public:
//	const int hour;
//	int minute;
//	int second;
//	Time(int h,int m,int s):hour(h),minute(m),second(s){}//对于常数据成员的初始化只能通过构造函数的参数初始化表
//	void get_time()const;//常成员函数
//};
//void Time::get_time()const
//{
//	cout << hour << ":" << minute << ":" << second << endl;
//
//}
//int main()
//{
//	Time t(1, 2, 3);
//	//t.hour = 2;//hour数据成员被const修饰，其值不能被修改。
//	t.get_time();//常成员函数只能调用本类中的数据成员，但是不能修改它们
//	return 0;
//}


//class Time
//{
//public:
//	Time(int h = 0,int m = 0 ,int s = 0):hour(h),minute(m),second(s){}//构造函数
//	~Time() { ; }//析构函数
//	void get_time1();
//	void get_time2()const;
//private:
//	int hour;
//	int minute;
//	mutable int second;
//};
//void Time::get_time1()
//{
//	cout << hour << ":" << minute << ":" << second << endl;
//}
//void Time::get_time2()const
//{
//	cout << hour << ":" << minute << ":" << second << endl;
//}
//int main()
//{
//	//定义常对象
//	//定义常对象默认数据成员都是const类型，其值都不可被修改，但是可以通过mutable关键字来定义常对象中的可变数据成员
//	const Time t(12, 21, 31);
//	t.get_time1();//常对象不能调用普通成员函数
//	t.get_time2();//常对象只能调用常成员函数
//	return 0;
//}

//class Time
//{
//public:
//	Time(int h, int m, int s) :hour(h), minute(m), sec(s) {}
//	int hour;
//	int minute;
//	int sec;
//	void get_time();
//};
//void Time::get_time()
//{
//	cout << hour << ":" << minute << ":" << sec << endl;
//}
//int main()
//{
//	Time t1(12, 12, 23);
//
//	//指向对象数据成员的指针
//	int* p1 = &t1.hour;
//	int* p2 = &t1.minute;
//	int* p3 = &t1.sec;
//	cout << *p1 << ":" << *p2 << ":" << *p3 << endl;
//
//	//指向对象的指针
//	Time* T = &t1;
//	cout << T->hour << endl;
//	T->get_time();
//
//	//指向对象成员函数的指针
//	void(Time:: * f)() = &Time::get_time;
//	(t1.*f)();
//	return 0;
//}

//class Box
//{
//public:
//	Box(int h = 20,int w = 12,int len = 15):height(h),width(w),length(len){}
//	int volume();
//private:
//	int height;
//	int width;
//	int length;
//};
//
//int Box::volume()
//{
//	return (height * width * length);
//}
//
//int main()
//{
//	Box a[3] = {
//	Box(10,12,15),
//	Box(15,18,20),
//	Box(16,20,26) 
//	};
//	cout << a[0].volume() << endl;
//	cout << a[1].volume() << endl;
//	cout << a[2].volume() << endl;
//	return 0;
//}

//定义构造函数可以使用默认参数
//class Time
//{
//public:
//	Time(int h = 1, int m = 2, int s = 3) :hour(h), minute(m), sec(s) {}
//	~Time()//析构函数
//	{
//		cout << "end" << endl;
//	}
//	void show_time();
//private:
//	int hour;
//	int minute;
//	int sec;
//};
//
//void Time::show_time()
//{
//	cout << hour << ":" << minute << ":" << sec << endl;
//}
//
//int main()
//{
//	Time t1(12, 21, 31);
//	t1.show_time();
//	Time t2;//当使用默认参数的时候，定义对象不能加()
//	t2.show_time();
//	return 0;
//}

//在构造函数中用参数初始化表对数据成员初始化
//class Time
//{
//public:
//	Time(int h, int m, int s) :hour(h), minute(m), sec(s){}
//	void show_time();
//private:
//	int hour;
//	int minute;
//	int sec;
//};
//
//void Time::show_time()
//{
//	cout << hour << ":" << minute << ":" << sec << endl;
//}
//
//int main()
//{
//	Time t1(12, 21, 31);
//	t1.show_time();
//	return 0;
//}

//用带参构造函数对不同对象进行初始化
//class Time
//{
//public:
//	Time(int h, int m, int s)
//	{
//		hour = h;
//		minute = m;
//		sec = s;
//	}
//	void show_time();
//private:
//	int hour;
//	int minute;
//	int sec;
//};
//
//void Time::show_time()
//{
//	cout << hour << ":" << minute << ":" << sec << endl;
//}
//
//int main()
//{
//	Time t1(12, 21, 31);
//	t1.show_time();
//	return 0;
//}

//class Time
//{
//public:
//	Time()//无参构造函数
//	{
//		hour = 0;
//		minute = 0;
//		sec = 0;
//	}
//	void set_time();
//	void show_time();
//private:
//	int hour;
//	int minute;
//	int sec;
//};
//
//void Time::set_time()
//{
//	cin >> hour >> minute >> sec;
//}
//
//void Time::show_time()
//{
//	cout << hour << ":" << minute << ":" << sec << endl;
//}

//int main()
//{
//	Time t1;
//	t1.set_time();
//	Time t2 = t1;
//	t2.show_time();
//	return 0;
//}

//int main()
//{
//	//利用无参构造函数对对象进行初始化
//	Time t1;
//	t1.show_time();
//
//	Time t2;
//	t2.set_time();//利用成员函数修改对象内成员变量的值
//	t2.show_time();
//	return 0;
//}



//class Volume
//{
//public:
//	void Volu()//对外接口
//	{
//		set();
//		calc();
//		show();
//	}
//private:
//	int length;
//	int width;
//	int height;
//	int Vol;	
//	void set()
//	{
//		cin >> length >> width >> height;
//	}
//	void calc()
//	{
//		Vol = length * width * height;
//	}
//	void show()
//	{
//		cout << "Volume = " << Vol << endl;
//	}
//};
//
//int main()
//{
//	Volume v1;
//	v1.Volu();
//	Volume v2;
//	v2.Volu();
//	Volume v3;
//	v3.Volu();
//	return 0;
//}


//class Time
//{
//	public:
//		void set_time();
//		void show_time();
//		int hour;
//		int minute;
//		int sec;
//};
//
//Time t;
//int main()
//{
//	t.set_time();
//	t.show_time();
//	return 0;
//}
//void Time::set_time()
//{
//	cin >> hour >> minute >> sec;
//}
//
//void Time::show_time()
//{
//	cout << hour << ":" << minute << ":" << sec << endl;
//}

//int main()
//{
//	Time t;//未初始化，会报错
//	cout << t.hour << " " << t.minute << " " << t.sec << endl;
//	return 0;
//}

//int main()
//{
//	Time t = { 1,32 };
//	Time& i = t;
//	cout << i.hour << " " << i.minute << endl;
//	return 0;
//}

//int main()
//{
//	Time t = { 1,2 };
//	Time* p = &t;
//
//	//t.hour = 1;
//	//t.minute = 2;
//	cout << t.hour << " " << t.minute << endl;	
//
//	p->hour = 2;
//	p->minute = 13;
//	cout << p->hour << " " << p->minute << endl;
//	return 0;
//}


//using namespace std;
//
//
//new int;//开辟一个整形的空间，返回一直指向整形数据的指针
//new int(100);//开辟一个整形的空间，并指定该整数的初始值为100
//new char[3];//开辟一个存放字符数组的空间，该空间可以存放3个字符，返回一个指向字符数据的指针
//new int[5][4];//开辟一个二维数组


//string str[3] = { "zhangsan","lisi","wangwu" };


//string s1 = "hello";
//string s2 = "world";
//s1 = s1 + s2;//连接s1和s2,s1 = "helloworld"
//
//
//str1 = str2;

//
//int main()
//{
//	string s1;
//	string s2;
//	cin >> s1 >> s2;
//	cout << s1 << s2 << endl;
//	return 0;
//}

//int main()
//{
//	string word = "she";
//	word[2] = 'a';//此时word的内容为"sha"
//	cout << word << endl;
//	return 0;
//}

//int main()
//{
//	string s1 = "ab";
//	string s2 = "china";
//	s2 = s1;//s2变成了ab
//	cout << s1 << endl << s2;
//	return 0;
//}

//float a = 1.1;
//
//int main()
//{
//	int a = 10;
//	cout << a << " " << ::a << endl;
//	return 0;
//}


//inline int max(int x, int y)
//{
//	return x > y ? x : y;
//}
//
//int main()
//{
//	int a = 1;
//	int b = 2;
//	int c = 0;
//	x = a;
//	y = b;
//	c = x > y ? x : y;
//	c = max(a, b);
//	cout << c << endl;
//	return 0;
//}

//int main()
//{
//	int i = 5;
//	const int& a = i + 3;
//	return 0;
//}


//int main()
//{
//	int a = 14;
//	const int& b = a;//用const修饰的引用不能被修改
//	b = 1;//错误
//	a = 1;//但是可以直接改变变量本身
//	return 0;
//}



//int i = 1;
//int* p = &i;
//int*& pr = p;


//int a = 3;
//int& b = a;
//int* p = &b;
//
//int&* p = &a;

//char a[4] = "abcd";
//char& r[6] = c;//错误

//void swap(int& a, int& b)
//{
//	int tmp = a;
//	a = b;
//	b = tmp;
//}
//
//int main()
//{
//	int a = 10;
//	int b = 99;
//	cout << "a = " << a << " " << "b = " << b << endl;
//	swap(a, b);
//	cout << "a = " << a << " " << "b = " << b << endl;
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	int& b = a;
//	int& c = b;
//	return 0;
//}


//int main()
//{
//	int a = 0;
//	int& b = a;
//	cout << &a << endl << &b << endl;
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	int& b = a;//正确，声明b是a的引用，即b是变量a的一个别名
//	int& b;//错误，没有指定b代表那个变量
//
//	float c = 1.1;
//	int& d = c;//错误，声明b是一个整形变量的别名，但是却让它代表了浮点型变量c
//
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	int& b = a;
//	a += 90;
//	cout << a << " " << b << endl;
//	b += 100;
//	cout << a << " " << b << endl;
//	return 0;
//}



//
//int main()
//{
//	int a = 10;
//	int b = 1;
//	int& c = a;
//	int& c = b;
//
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	int& b = a;//声明b是整型变量a的引用
//
//	b = 3;
//	cout << a << " " << b << endl;
//	return 0;
//}


//void f1(int x, int y, int z = 0, int n);//错误
//f1(1, 2, 3);
//
//void f2(int x,int y,int n,int z = 0)//正确

//
//float V(float h,float r = 6.53);
//
//V(32.1);//h为32.1，r为默认值6.53
//
//V(32.1, 12.1);//h为32.1，r为12.1
//
//int main()
//{
//	V(1.2);//r = 1.2
//	return 0;
//}

//template<typename T1,typename T2>
//
//
//template<typename T>
//T tmax(T x, T y)
//{
//	return x > y ? x : y;
//}
//
//int main()
//{
//	int a = 1;
//	int b = 2;
//	float c = 1.2f;
//	float d = 3.2f;
//	char e = 'a';
//	char f = 'x';
//	cout << tmax(a, b) << endl;
//	cout << tmax(c,d) << endl;
//	cout << tmax(e,f) << endl;
//	return 0;
//}


//int max(int x, int y)
//{
//	return x > y ? x : y;
//}
//
//int max(int x, int y, int z)
//{
//	if (x < y)
//	{
//		x = y;
//	}
//	if (x < z)
//	{
//		x = z;
//	}
//	return z;
//}
//
//int main()
//{
//	int a = 1;
//	int b = 2;
//	int c = 3;
//	cout << max(a, b) << endl;
//	cout << max(a, b, c) << endl;
//	return 0;
//}

//int max(int x, int y)
//{
//	return x > y ? x : y;
//}
//
//float max(float x, float y)
//{
//	return x > y ? x : y;
//}
//
//char max(char x, char y)
//{
//	return x > y ? x : y;
//}
//
//int main()
//{
//	int a = 1;
//	int b = 2;
//	float c = 1.2f;
//	float d = 3.2f;
//	char e = 'a';
//	char f = 'x';
//	cout << max(a, b) << endl;
//	cout << max(c,d) << endl;
//	cout << max(e,f) << endl;
//	return 0;
//}


//int main()
//{
//	int max(int x, int y);
//	int a = 0;
//	int b = 0;
//	cin >> a >> b;
//	cout << max(a, b) << endl;
//}
//
//int max(int x, int y)
//{
//	return x > y ? x : y;
//}

//int main()
//{
//	const int a = 10;
//	a = 12;
//}

//int main()
//{
//	int a = 0;
//	float b = 0.0f;
//	cin >> a >> b;//不可以写成 cin>>a,b;
//	cout << a <<" " << b << endl;
//	const int a = 10;
//	return 0;
//}


//int main()
//{
//	int a = 0;
//	cin >> a;//scanf("%d",&a);
//	cout << a << endl;
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	cout << a << endl;
//	cout << setw(3) << a << endl;
//	cout << left << setw(3) << a << endl;
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	cout <<"a = "<< a << endl;
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	cout << a << endl;
//	//printf("%d\n",a);
//	return 0;
//}

////利用函数模板，对上述函数重载进行简化
//
//template<typename T>
//T amax(T x, T y)
//{
//	return x > y ? x : y;
//}
//
//int main()
//{
//	int a = 10;
//	int b = 2;
//	float c = 1.1f;
//	float d = 3.2f;
//	char e = '1';
//	char f = '3';
//	cout << amax(a, b) << endl;
//	cout << amax(c, d) << endl;
//	cout << amax(e,f) << endl;
//	return 0;
//}

//函数重载
//int max(int x, int y)
//{
//	return x > y ? x : y;
//}
//
//float max(float x, float y)
//{
//	return x > y ? x : y;
//}
//
//char max(char x, char y)
//{
//	return x > y ? x : y;
//}
//
//int main()
//{
//	int a = 10;
//	int b = 2;
//	float c = 1.1f;
//	float d = 3.2f;
//	char e = '1';
//	char f = '3';
//	cout << max(a, b) << endl << max(c, d) << endl << max(e, f) << endl;
//	return 0;
//}


//int main()
//{
//	//C++动态内存分配和撤销
//	int* p = new int(12);//申请一个整形大小的空间并赋值给p初始化为12
//	if (p == NULL)
//	{
//		perror("new");
//		exit(-1);
//	}
//	cout << *p << endl;
//	*p = 1;
//	cout << *p << endl;
//	delete p;//使用完后，将动态分配的内存空间撤销
//	p = NULL;
//
//	//动态分配一个数组大小为10
//	int* pf = new int[10];
//	if (pf == NULL)
//	{
//		perror("new");
//		exit(-1);
//	}
//	cout << "请输入十个整数" << endl;
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		cin >> pf[i];
//	}
//	for (i = 0; i < 10; i++)
//	{
//		cout << pf[i];
//	}
//	delete[]pf;
//	pf = NULL;
//	return 0;
//}

//int main()
//{
//	//字符串变量的运算
//	string s1 = "hello world";
//	string s2 = "hello newcoder";
//	cout << s1 << " " << s2 << endl;
//
//	//字符串复制用赋值号
//	s1 = s2;//将字符串2复制到字符串1
//	cout << s1 << " " << s2 << endl;
//
//	//字符串连接用+号
//	s1 += s2;
//	cout << s1 << " " << s2 << endl;
//
//	//字符串比较直接用关系运算符
//	string s3 = "abcdef";
//	string s4 = "abcq";
//	string max = s3 > s4 ? s3 : s4;
//	cout << max << endl;
//
//	//字符串数组
//	string name[3];
//	name[0] = "zhangsan";
//	name[1] = "lisi";
//	name[2] = "wangwu";
//	int i = 0;
//	for (i = 0; i < 3; i++)
//	{
//		cout << name[i] << endl;
//	}
//	return 0;
//}


//int main()
//{
//	string string1 = "hehe";
//	string string2 = "hello world";
//	cout << string1 << " " << string2 << endl;
//
//	string1 = string2;//将字符串2复制给字符串1
//	cout << string1 << " " << string2 << endl;//定义字符串变量的时候不用指定长度，因为该字符串变量其实存的是字符串的地址
//
//	string1 = "tua";
//	string2 = string1;
//	cout << string1 << " " << string2 << endl;
//
//	//可以对字符串变量的某个字符进行操作
//	string1[2] = 't';//string1[2]其实就是第三个字符'a',将其改成了't'
//	cout << string1 << endl;
//
//	//字符串变量的输入输出
//	string s1 = "";
//	string s2 = "";
//	cout << "请输入两个字符串" << endl;
//	cin >> s1 >> s2;
//	cout << s1 << " " << s2 << endl;
//	return 0;
//}

//int a = 10;
//
//int main()
//{
//	int a = 1;
//	cout << a <<endl<<::a << endl;//不能用::访问函数中的局部变量
//	return 0;
//}


//int main()
//{
//	int i = 3;
//	const int& a = i + 3;
//	//上面的代码相当于：
//	//int tmp = i+3;
//	//const int &a = tmp;
//	cout << i << a << endl;
//	return 0;
//}


//int main()
//{
//	int i = 5;
//	int&* p = &i;//不允许使用指向引用类型的指针
//	return 0;
//}


//int main()
//{
//	int i = 5;
//	int* p = &i;
//	int*& pt = p;//定义一个指向指针变量的引用pt
//	cout << i << *p << *pt<<endl;
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	int b = 2;
//	//c已经作为a的别名，就不能再作为b的别名了
//	int& c = a;
//	int& c = b;
//	b -= 1;
//	c -= 1;
//	cout << a << b << c << endl;
//	return 0;
//}

//int main()
//{
//	int a = 10;//一个变量可有多个别名，每一个别名都会影响该变量
//	int& b = a;
//	int& c = a;
//	b -= 1;
//	c -= 1;
//	cout << a << b << c << endl;
//	return 0;
//}